home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / File / Passwd / Unix.php < prev   
PHP Script  |  2004-10-01  |  19KB  |  650 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PEAR :: File :: Passwd :: Unix                                       |
  4. // +----------------------------------------------------------------------+
  5. // | This source file is subject to version 3.0 of the PHP license,       |
  6. // | that is available at http://www.php.net/license/3_0.txt              |
  7. // | If you did not receive a copy of the PHP license and are unable      |
  8. // | to obtain it through the world-wide-web, please send a note to       |
  9. // | license@php.net so we can mail you a copy immediately.               |
  10. // +----------------------------------------------------------------------+
  11. // | Copyright (c) 2003-2004 Michael Wallner <mike@iworks.at>             |
  12. // +----------------------------------------------------------------------+
  13. //
  14. // $Id: Unix.php,v 1.15 2004/06/07 19:19:47 mike Exp $
  15.  
  16. /**
  17. * Manipulate standard Unix passwd files.
  18. * 
  19. * @author   Michael Wallner <mike@php.net>
  20. * @package  File_Passwd
  21. */
  22.  
  23. /**
  24. * Requires File::Passwd::Common
  25. */
  26. require_once 'File/Passwd/Common.php';
  27.  
  28. /**
  29. * Manipulate standard Unix passwd files.
  30. * 
  31. * <kbd><u>Usage Example:</u></kbd>
  32. * <code>
  33. *   $passwd = &File_Passwd::factory('Unix');
  34. *   $passwd->setFile('/my/passwd/file');
  35. *   $passwd->load();
  36. *   $passwd->addUser('mike', 'secret');
  37. *   $passwd->save();
  38. * </code>
  39. * 
  40. * 
  41. * <kbd><u>Output of listUser()</u></kbd>
  42. * # using the 'name map':
  43. * <pre>
  44. *      array
  45. *       + user  => array
  46. *                   + pass  => crypted_passwd or 'x' if shadowed
  47. *                   + uid   => user id
  48. *                   + gid   => group id
  49. *                   + gecos => comments
  50. *                   + home  => home directory
  51. *                   + shell => standard shell
  52. * </pre>
  53. * # without 'name map':
  54. * <pre>
  55. *      array
  56. *       + user  => array
  57. *                   + 0  => crypted_passwd
  58. *                   + 1  => ...
  59. *                   + 2  => ...
  60. * </pre>
  61. * 
  62. * @author   Michael Wallner <mike@php.net>
  63. * @package  File_Passwd
  64. * @version  $Revision: 1.15 $
  65. * @access   public
  66. */
  67. class File_Passwd_Unix extends File_Passwd_Common
  68. {
  69.     /**
  70.     * A 'name map' wich refer to the extra properties
  71.     *
  72.     * @var array
  73.     * @access private
  74.     */
  75.     var $_map = array('uid', 'gid', 'gecos', 'home', 'shell');
  76.     
  77.     /**
  78.     * Whether to use the 'name map' or not
  79.     *
  80.     * @var boolean
  81.     * @access private
  82.     */
  83.     var $_usemap = true;
  84.     
  85.     /**
  86.     * Whether the passwords of this passwd file are shadowed in another file
  87.     *
  88.     * @var boolean
  89.     * @access private
  90.     */
  91.     var $_shadowed = false;
  92.     
  93.     /**
  94.     * Encryption mode, either md5 or des
  95.     *
  96.     * @var string
  97.     * @access private
  98.     */
  99.     var $_mode = 'des';
  100.     
  101.     /**
  102.     * Supported encryption modes
  103.     * 
  104.     * @var array
  105.     * @access private
  106.     */
  107.     var $_modes = array('md5' => 'md5', 'des' => 'des');
  108.     
  109.     /**
  110.     * Constructor
  111.     *
  112.     * @access public
  113.     * @param  string    $file   path to passwd file
  114.     */
  115.     function File_Passwd_Unix($file = 'passwd')
  116.     {
  117.         parent::__construct($file);
  118.     }
  119.     
  120.     /**
  121.     * Fast authentication of a certain user
  122.     * 
  123.     * Returns a PEAR_Error if:
  124.     *   o file doesn't exist
  125.     *   o file couldn't be opened in read mode
  126.     *   o file couldn't be locked exclusively
  127.     *   o file couldn't be unlocked (only if auth fails)
  128.     *   o file couldn't be closed (only if auth fails)
  129.     *   o invalid encryption mode <var>$mode</var> was provided
  130.     *
  131.     * @static   call this method statically for a reasonable fast authentication
  132.     * @access   public
  133.     * @return   mixed   true if authenticated, false if not or PEAR_Error
  134.     * @param    string  $file   path to passwd file
  135.     * @param    string  $user   user to authenticate
  136.     * @param    string  $pass   plaintext password
  137.     * @param    string  $mode   encryption mode to use (des or md5)
  138.     */
  139.     function staticAuth($file, $user, $pass, $mode)
  140.     {
  141.         $line = File_Passwd_Common::_auth($file, $user);
  142.         if (!$line || PEAR::isError($line)) {
  143.             return $line;
  144.         }
  145.         list(,$real)= explode(':', $line);
  146.         $crypted    = File_Passwd_Unix::_genPass($pass, $real, $mode);
  147.         if (PEAR::isError($crypted)) {
  148.             return $crypted;
  149.         }
  150.         return ($crypted === $real);
  151.     }
  152.     
  153.     /**
  154.     * Apply changes an rewrite passwd file
  155.     *
  156.     * Returns a PEAR_Error if:
  157.     *   o directory in which the file should reside couldn't be created
  158.     *   o file couldn't be opened in write mode
  159.     *   o file couldn't be locked exclusively
  160.     *   o file couldn't be unlocked
  161.     *   o file couldn't be closed
  162.     * 
  163.     * @throws PEAR_Error
  164.     * @access public
  165.     * @return mixed true on success or PEAR_Error
  166.     */
  167.     function save()
  168.     {
  169.         $content = '';
  170.         foreach ($this->_users as $user => $array){
  171.             $pass   = array_shift($array);
  172.             $extra  = implode(':', $array);
  173.             $content .= $user . ':' . $pass;
  174.             if (!empty($extra)) {
  175.                 $content .= ':' . $extra;
  176.             }
  177.             $content .= "\n";
  178.         }
  179.         return $this->_save($content);
  180.     }
  181.     
  182.     /**
  183.     * Parse the Unix password file
  184.     *
  185.     * Returns a PEAR_Error if passwd file has invalid format.
  186.     * 
  187.     * @throws PEAR_Error
  188.     * @access public
  189.     * @return mixed true on success or PEAR_Error
  190.     */
  191.     function parse()
  192.     {
  193.         $this->_users = array();
  194.         foreach ($this->_contents as $line){
  195.             $parts = explode(':', $line);
  196.             if (count($parts) < 2) {
  197.                 return PEAR::raiseError(
  198.                     FILE_PASSWD_E_INVALID_FORMAT_STR,
  199.                     FILE_PASSWD_E_INVALID_FORMAT
  200.                 );
  201.             }
  202.             $user = array_shift($parts);
  203.             $pass = array_shift($parts);
  204.             if ($pass == 'x') {
  205.                 $this->_shadowed = true;
  206.             }
  207.             $values = array();
  208.             if ($this->_usemap) {
  209.                 $values['pass'] = $pass;
  210.                 foreach ($parts as $i => $value){
  211.                     if (isset($this->_map[$i])) {
  212.                         $values[$this->_map[$i]] = $value;
  213.                     } else {
  214.                         $values[$i+1] = $value;
  215.                     }
  216.                 }
  217.             } else {
  218.                 $values = array_merge(array($pass), $parts);
  219.             }
  220.             $this->_users[$user] = $values;
  221.             
  222.         }
  223.         $this->_contents = array();
  224.         return true;
  225.     }
  226.     
  227.     /**
  228.     * Set the encryption mode
  229.     * 
  230.     * Supported encryption modes are des and md5.
  231.     * 
  232.     * Returns a PEAR_Error if supplied encryption mode is not supported.
  233.     *
  234.     * @see      setMode()
  235.     * @see      listModes()
  236.     * 
  237.     * @throws   PEAR_Error
  238.     * @access   public
  239.     * @return   mixed   true on succes or PEAR_Error
  240.     * @param    string  $mode   encryption mode to use; either md5 or des
  241.     */
  242.     function setMode($mode)
  243.     {
  244.         $mode = strToLower($mode);
  245.         if (!isset($this->_modes[$mode])) {
  246.             return PEAR::raiseError(
  247.                 sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $mode),
  248.                 FILE_PASSWD_E_INVALID_ENC_MODE
  249.             );
  250.         }
  251.         $this->_mode = $mode;
  252.         return true;
  253.     }
  254.     
  255.     /** 
  256.     * Get supported encryption modes
  257.     *
  258.     * <pre>
  259.     *   array
  260.     *    + md5
  261.     *    + des
  262.     * </pre>
  263.     * 
  264.     * @see      setMode()
  265.     * @see      getMode()
  266.     * 
  267.     * @access   public
  268.     * @return   array
  269.     */
  270.     function listModes()
  271.     {
  272.         return $this->_modes;
  273.     }
  274.  
  275.     /**
  276.     * Get actual encryption mode
  277.     *
  278.     * @see      listModes()
  279.     * @see      setMode()
  280.     * 
  281.     * @access   public
  282.     * @return   string
  283.     */
  284.     function getMode()
  285.     {
  286.         return $this->_mode;
  287.     }
  288.     
  289.     /**
  290.     * Whether to use the 'name map' of the extra properties or not
  291.     * 
  292.     * Default Unix passwd files look like:
  293.     * <pre>
  294.     * user:password:user_id:group_id:gecos:home_dir:shell
  295.     * </pre>
  296.     * 
  297.     * The default 'name map' for properties except user and password looks like:
  298.     *   o uid
  299.     *   o gid
  300.     *   o gecos
  301.     *   o home
  302.     *   o shell
  303.     * 
  304.     * If you want to change the naming of the standard map use 
  305.     * File_Passwd_Unix::setMap(array()).
  306.     *
  307.     * @see      setMap()
  308.     * @see      getMap()
  309.     * 
  310.     * @access   public
  311.     * @return   boolean always true if you set a value (true/false) OR
  312.     *                   the actual value if called without param
  313.     * 
  314.     * @param    boolean $bool   whether to use the 'name map' or not
  315.     */
  316.     function useMap($bool = null)
  317.     {
  318.         if (is_null($bool)) {
  319.             return $this->_usemap;
  320.         }
  321.         $this->_usemap = (bool) $bool;
  322.         return true;
  323.     }
  324.     
  325.     /**
  326.     * Set the 'name map' to use with the extra properties of the user
  327.     * 
  328.     * This map is used for naming the associative array of the extra properties.
  329.     *
  330.     * Returns a PEAR_Error if <var>$map</var> was not of type array.
  331.     * 
  332.     * @see      getMap()
  333.     * @see      useMap()
  334.     * 
  335.     * @throws   PEAR_Error
  336.     * @access   public
  337.     * @return   mixed       true on success or PEAR_Error
  338.     */
  339.     function setMap($map = array())
  340.     {
  341.         if (!is_array($map)) {
  342.             return PEAR::raiseError(
  343.                 sprintf(FILE_PASSWD_E_PARAM_MUST_BE_ARRAY_STR, '$map'),
  344.                 FILE_PASSWD_E_PARAM_MUST_BE_ARRAY
  345.             );
  346.         }
  347.         $this->_map = $map;
  348.         return true;
  349.     }
  350.     
  351.     /**
  352.     * Get the 'name map' which is used for the extra properties of the user
  353.     *
  354.     * @see      setMap()
  355.     * @see      useMap()
  356.     * 
  357.     * @access public
  358.     * @return array
  359.     */
  360.     function getMap()
  361.     {
  362.         return $this->_map;
  363.     }
  364.     
  365.     /**
  366.     * If the passwords of this passwd file are shadowed in another file.
  367.     *
  368.     * @access public
  369.     * @return boolean
  370.     */
  371.     function isShadowed()
  372.     {
  373.         return $this->_shadowed;
  374.     }
  375.     
  376.     /**
  377.     * Add an user
  378.     *
  379.     * The username must start with an alphabetical character and must NOT
  380.     * contain any other characters than alphanumerics, the underline and dash.
  381.     * 
  382.     * If you use the 'name map' you should also use these naming in
  383.     * the supplied extra array, because your values would get mixed up
  384.     * if they are in the wrong order, which is always true if you
  385.     * DON'T use the 'name map'!
  386.     * 
  387.     * So be warned and USE the 'name map'!
  388.     * 
  389.     * If the passwd file is shadowed, the user will be added though, but
  390.     * with an 'x' as password, and a PEAR_Error will be returned, too.
  391.     * 
  392.     * Returns a PEAR_Error if:
  393.     *   o user already exists
  394.     *   o user contains illegal characters
  395.     *   o encryption mode is not supported
  396.     *   o passwords are shadowed in another file
  397.     *   o any element of the <var>$extra</var> array contains a colon (':')
  398.     * 
  399.     * @throws PEAR_Error
  400.     * @access public
  401.     * @return mixed true on success or PEAR_Error
  402.     * @param  string    $user   the name of the user to add
  403.     * @param  string    $pass   the password of the user to add
  404.     * @param  array     $extra  extra properties of user to add
  405.     */
  406.     function addUser($user, $pass, $extra = array())
  407.     {
  408.         if ($this->userExists($user)) {
  409.             return PEAR::raiseError(
  410.                 sprintf(FILE_PASSWD_E_EXISTS_ALREADY_STR, 'User ', $user),
  411.                 FILE_PASSWD_E_EXISTS_ALREADY
  412.             );
  413.         }
  414.         if (!preg_match($this->_pcre, $user)) {
  415.             return PEAR::raiseError(
  416.                 sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
  417.                 FILE_PASSWD_E_INVALID_CHARS
  418.             );
  419.         }
  420.         if (!is_array($extra)) {
  421.             setType($extra, 'array');
  422.         }
  423.         foreach ($extra as $e){
  424.             if (strstr($e, ':')) {
  425.             return PEAR::raiseError(
  426.                 sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'Property ', $e),
  427.                 FILE_PASSWD_E_INVALID_CHARS
  428.             );
  429.             }
  430.         }
  431.         
  432.         /**
  433.         * If passwords of the passwd file are shadowed, 
  434.         * the password of the user will be set to 'x'.
  435.         */
  436.         if ($this->_shadowed) {
  437.             $pass = 'x';
  438.         } else {
  439.             $pass = $this->_genPass($pass);
  440.             if (PEAR::isError($pass)) {
  441.                 return $pass;
  442.             }
  443.         }
  444.         
  445.         /**
  446.         * If you don't use the 'name map' the user array will be numeric.
  447.         */
  448.         if (!$this->_usemap) {
  449.             array_unshift($extra, $pass);
  450.             $this->_users[$user] = $extra;
  451.         } else {
  452.             $map = $this->_map;
  453.             array_unshift($map, 'pass');
  454.             $extra['pass'] = $pass;
  455.             foreach ($map as $key){
  456.                 $this->_users[$user][$key] = @$extra[$key];
  457.             }
  458.         }
  459.         
  460.         /**
  461.         * Raise a PEAR_Error if passwords are shadowed.
  462.         */
  463.         if ($this->_shadowed) {
  464.             return PEAR::raiseError(
  465.                 'Password has been set to \'x\' because they are '.
  466.                 'shadowed in another file.', 0
  467.             );
  468.         }
  469.         return true;
  470.     }
  471.     
  472.     /**
  473.     * Modify properties of a certain user
  474.     *
  475.     * # DON'T MODIFY THE PASSWORD WITH THIS METHOD!
  476.     * 
  477.     * You should use this method only if the 'name map' is used, too.
  478.     * 
  479.     * Returns a PEAR_Error if:
  480.     *   o user doesn't exist
  481.     *   o any property contains a colon (':')
  482.     * 
  483.     * @see      changePasswd()
  484.     * 
  485.     * @throws   PEAR_Error
  486.     * @access   public
  487.     * @return   mixed       true on success or PEAR_Error
  488.     * @param    string      $user           the user to modify
  489.     * @param    array       $properties     an associative array of 
  490.     *                                       properties to modify
  491.     */
  492.     function modUser($user, $properties = array())
  493.     {
  494.         if (!$this->userExists($user)) {
  495.             return PEAR::raiseError(
  496.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  497.                 FILE_PASSWD_E_EXISTS_NOT
  498.             );
  499.         }
  500.         
  501.         if (!is_array($properties)) {
  502.             setType($properties, 'array');
  503.         }
  504.         
  505.         foreach ($properties as $key => $value){
  506.             if (strstr($value, ':')) {
  507.                 return PEAR::raiseError(
  508.                     sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
  509.                     FILE_PASSWD_E_INVALID_CHARS
  510.                 );
  511.             }
  512.             $this->_users[$user][$key] = $value;
  513.         }
  514.         
  515.         return true;
  516.     }
  517.     
  518.     /**
  519.     * Change the password of a certain user
  520.     *
  521.     * Returns a PEAR_Error if:
  522.     *   o user doesn't exists
  523.     *   o passwords are shadowed in another file
  524.     *   o encryption mode is not supported
  525.     * 
  526.     * @throws PEAR_Error
  527.     * @access public
  528.     * @return mixed true on success or PEAR_Error
  529.     * @param string $user   the user whose password should be changed
  530.     * @param string $pass   the new plaintext password
  531.     */
  532.     function changePasswd($user, $pass)
  533.     {
  534.         if ($this->_shadowed) {
  535.             return PEAR::raiseError(
  536.                 'Passwords of this passwd file are shadowed.', 
  537.                 0
  538.             );
  539.         }
  540.         
  541.         if (!$this->userExists($user)) {
  542.             return PEAR::raiseError(
  543.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  544.                 FILE_PASSWD_E_EXISTS_NOT
  545.             );
  546.         }
  547.         
  548.         $pass = $this->_genPass($pass);
  549.         if (PEAR::isError($pass)) {
  550.             return $pass;
  551.         }
  552.         
  553.         if ($this->_usemap) {
  554.             $this->_users[$user]['pass'] = $pass;
  555.         } else {
  556.             $this->_users[$user][0] = $pass;
  557.         }
  558.         
  559.         return true;
  560.     }
  561.     
  562.     /**
  563.     * Verify the password of a certain user
  564.     * 
  565.     * Returns a PEAR_Error if:
  566.     *   o user doesn't exist
  567.     *   o encryption mode is not supported
  568.     *
  569.     * @throws PEAR_Error
  570.     * @access public
  571.     * @return mixed true if passwors equal, false if they don't or PEAR_Error
  572.     * @param  string    $user   the user whose password should be verified
  573.     * @param  string    $pass   the password to verify
  574.     */
  575.     function verifyPasswd($user, $pass)
  576.     {
  577.         if (!$this->userExists($user)) {
  578.             return PEAR::raiseError(
  579.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  580.                 FILE_PASSWD_E_EXISTS_NOT
  581.             );
  582.         }
  583.         $real = 
  584.             $this->_usemap ? 
  585.             $this->_users[$user]['pass'] : 
  586.             $this->_users[$user][0]
  587.         ;
  588.         return ($real === $this->_genPass($pass, $real));
  589.     }
  590.     
  591.     /**
  592.     * Generate crypted password from the plaintext password
  593.     *
  594.     * Returns a PEAR_Error if actual encryption mode is not supported.
  595.     * 
  596.     * @throws PEAR_Error
  597.     * @access private
  598.     * @return mixed     the crypted password or PEAR_Error
  599.     * @param  string    $pass   the plaintext password
  600.     * @param  string    $salt   the crypted password from which to gain the salt
  601.     * @param  string    $mode   the encryption mode to use; don't set, because
  602.     *                           it's usually taken from File_Passwd_Unix::_mode
  603.     */
  604.     function _genPass($pass, $salt = null, $mode = null)
  605.     {
  606.         static $crypters;
  607.         if (!isset($crypters)) {
  608.             $crypters = get_class_methods('File_Passwd');
  609.         }
  610.         
  611.         $mode = !isset($mode) ? strToLower($this->_mode) : strToLower($mode);
  612.         $func = 'crypt_' . $mode;
  613.         
  614.         if (!in_array($func, $crypters)) {
  615.             return PEAR::raiseError(
  616.                 sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $mode),
  617.                 FILE_PASSWD_E_INVALID_ENC_MODE
  618.             );
  619.         }
  620.         
  621.         return call_user_func(array('File_Passwd', $func), $pass, $salt);
  622.     }
  623.     
  624.     /**
  625.     * Generate Password
  626.     *
  627.     * Returns PEAR_Error FILE_PASSD_E_INVALID_ENC_MODE if the supplied
  628.     * encryption mode is not supported.
  629.     *
  630.     * @see File_Passwd
  631.     * @static
  632.     * @access   public
  633.     * @return   mixed   The crypted password on success or PEAR_Error on failure.
  634.     * @param    string  $pass The plaintext password.
  635.     * @param    string  $mode The encryption mode to use.
  636.     * @param    string  $salt The salt to use.
  637.     */
  638.     function generatePassword($pass, $mode = 'md5', $salt = null)
  639.     {
  640.         if (!isset($mode)) {
  641.             return PEAR::raiseError(
  642.                 sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, '<NULL>'),
  643.                 FILE_PASSWD_E_INVALID_ENC_MODE                
  644.             );
  645.         }
  646.         return File_Passwd_Unix::_genPass($pass, $salt, $mode);
  647.     }
  648.     
  649. }
  650. ?>